import { Card } from "antd";
import "../../../common/common.css";

export const PanelArrayData = [
    {
        key: "1",
        label: "数组分割/裁剪",
        children: (
            <div className="centerTextLeft lodashPanel lodashWidth">
                <Card title="chunk" className="lodashCard">
                    <p>
                        _.chunk(array, [size=1]) <br />
                        <b>【数组拆分多个长度的区块】</b>
                    </p>
                    <p>将数组（array）拆分成多个 size 长度的区块，并将这些区块组成一个新数组。 如果array 无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块。</p>
                    <p>返回新的二维数组</p>
                </Card>
                <Card title="slice" className="lodashCard">
                    <p>
                        _.slice(array, [start=0], [end=array.length]) <br />
                        <b>【裁剪数组】</b>
                    </p>
                    <p> 裁剪数组array，从 start 位置开始到end结束，但不包括 end 本身的位置。Note: 这个方法用于代替Array#slice 来确保数组正确返回。</p>
                    <p>返回处理后的新数组</p>
                </Card>
                <Card title="take" className="lodashCard">
                    <p>
                        _.take(array, [n=1]) <br />
                        <b>【数组截取/清空】</b>
                    </p>
                    <p>创建一个数组切片，从array数组的起始元素开始提取n个元素。</p>
                    <p>返回 array 数组的切片</p>
                </Card>
                <Card title="takeRight" className="lodashCard">
                    <p>
                        _.takeRight(array, [n=1]) <br />
                        <b>【从末尾开始对数组截取/清空】</b>
                    </p>
                    <p>创建一个数组切片，从array数组的最后一个元素开始提取n个元素。</p>
                    <p>返回 array 数组的切片</p>
                </Card>
                <Card title="takeWhile" className="lodashCard">
                    <p>
                        _.takeWhile(array, [predicate=_.identity]) <br />
                        <b>【 对符合条件的进行截取 】</b>
                    </p>
                    <p>从array数组的起始元素开始提取元素，，直到 predicate 返回假值。predicate 会传入三个参数： (value, index, array)。</p>
                    <p>返回 array 数组的切片</p>
                </Card>
                <Card title="takeRightWhile" className="lodashCard">
                    <p>
                        _.takeRightWhile(array, [predicate=_.identity]) <br />
                        <b>【 从数组末尾开始对符合条件的进行截取 】</b>
                    </p>
                    <p>从array数组的最后一个元素开始提取元素，直到 predicate 返回假值。predicate 会传入三个参数： (value, index, array)。</p>
                    <p>返回 array 数组的切片</p>
                </Card>
            </div>
        ),
    },
    {
        key: "2",
        label: "数组过滤与删除",
        children: (
            <div className="centerTextLeft lodashPanel lodashWidth">
                <Card title="drop" className="lodashCard">
                    <p>
                        _.drop(array, [n=1]) <br /> <b>【删除数组开始元素】</b>{" "}
                    </p>
                    <p>创建一个切片数组，去除array前面的n个元素。（n默认值为1。）</p>
                    <p>返回删除后的数组</p>
                </Card>
                <Card title="dropRight" className="lodashCard">
                    <p>
                        _.dropRight(array, [n=1]) <br /> <b>【删除数组末尾元素】</b>{" "}
                    </p>
                    <p>创建一个切片数组，去除array尾部的n个元素。（n默认值为1。）</p>
                    <p>返回删除后的数组</p>
                </Card>
                <Card title="dropRightWhile & dropWhile" className="lodashCard">
                    <p>没理解</p>
                </Card>
                <Card title="tail" className="lodashCard">
                    <p>
                        _.tail(array) <br /> <b>【删除第一个元素】</b>
                    </p>
                    <p>获取除了array数组第一个元素以外的全部元素。</p>
                    <p>返回删除后的数组</p>
                </Card>
                <Card title="initial" className="lodashCard">
                    <p>
                        _.initial(array) <br /> <b>【删除数组的最后一个元素】</b>{" "}
                    </p>
                    <p>获取数组array中除了最后一个元素之外的所有元素（注： 去除数组array中的最后一个元素 ）。</p>
                    <p>返回删除后的数组</p>
                </Card>
                <Card title="pull" className="lodashCard">
                    <p>
                        _.pull(array, [values]) <br /> <b>【删除指定元素】</b>{" "}
                    </p>
                    <p>移除数组array中所有和给定值相等的元素，使用SameValueZero 进行全等比较。注意： 和_.without 方法不同，这个方法会改变数组。使用_.remove 从一个数组中移除元素。</p>
                    <p>返回删除后的数组</p>
                </Card>
                <Card title="pullAll" className="lodashCard">
                    <p>
                        _.pullAll(array, values) <br /> <b>【删除指定元素】</b>
                    </p>
                    <p>这个方法类似_.pull，区别是这个方法接收一个要移除值的数组。Note: 不同于_.difference, 这个方法会改变数组 array。</p>
                    <p>返回删除后的数组</p>
                </Card>
                <Card title="pullAllBy" className="lodashCard">
                    <p>
                        _.pullAllBy(array, values, [iteratee=_.identity]) <br /> <b>【处理数组后删除指定元素，可用于对象数组筛选指定元素】</b>
                    </p>
                    <p>
                        这个方法类似于_.pullAll ，区别是这个方法接受一个 iteratee（迭代函数） 调用 array 和 values的每个值以产生一个值，通过产生的值进行了比较。iteratee 会传入一个参数： (value)。Note: 不同于_.differenceBy,
                        这个方法会改变数组 array。
                    </p>
                    <p>返回一个过滤后新的数组</p>
                </Card>
                <Card title="pullAllWith" className="lodashCard">
                    <p>
                        _.pullAllWith(array, values, [comparator]) <br /> <b>【先进行比较再进行删除指定元素】</b>
                    </p>
                    <p>这个方法类似于_.pullAll，区别是这个方法接受 comparator 调用array中的元素和values比较。comparator 会传入两个参数：(arrVal, othVal)。注意: 和_.differenceWith 不同, 这个方法会改变数组 array。</p>
                    <p>返回一个过滤后新的数组</p>
                </Card>
                <Card title="pullAt" className="lodashCard">
                    <p>_.pullAt(array, [indexes])</p>
                    <p>根据索引 indexes，移除array中对应的元素，并返回被移除元素的数组。Note: 和_.at不同, 这个方法会改变数组 array。</p>
                    <p>返回一个删除后新的数组</p>
                </Card>
                <Card title="remove" className="lodashCard">
                    <p>
                        _.remove(array, [predicate=_.identity]) <br /> <b>【删除指定元素】</b>
                    </p>
                    <p>
                        移除数组中predicate（断言）返回为真值的所有元素，并返回移除元素组成的数组。predicate（断言） 会传入3个参数： (value, index, array)。 Note: 和_.filter不同, 这个方法会改变数组
                        array。使用_.pull来根据提供的value值从数组中移除元素。
                    </p>
                    <p>返回一个过滤后新的数组</p>
                </Card>
                <Card title="without" className="lodashCard">
                    <p>
                        _.without(array, [values]) <br /> <b>【删除指定元素】</b>
                    </p>
                    <p>创建一个剔除所有给定值的新数组，剔除值的时候，使用SameValueZero做相等比较。 注意: 不像_.pull, 这个方法会返回一个新数组。</p>
                    <p>返回一个过滤后新的数组</p>
                </Card>
                <Card title="compact" className="lodashCard">
                    <p>
                        _.compact(array) <br /> <b>【删除数组中值未假的元素（例如false, null,0, '', undefined, 和 NaN）】</b>
                    </p>
                    <p>创建一个新数组，包含原数组中所有的非假值元素。例如false, null,0, '', undefined, 和 NaN 都是被认为是“假值”。</p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="difference" className="lodashCard">
                    <p>
                        _.difference(array, [values]) <br /> <b>【删除数组给定范围内的元素】</b>
                    </p>
                    <p>
                        创建一个具有唯一array值的数组，每个值不包含在其他给定的数组中。（注：即创建一个新数组，这个数组中的值，为第一个数字（array
                        参数）排除了给定数组中的值。）该方法使用SameValueZero做相等比较。结果值的顺序是由第一个数组中的顺序确定。
                    </p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="differenceBy" className="lodashCard">
                    <p>
                        _.differenceBy(array, [values], [iteratee=_.identity]) <br /> <b>【删除数组给定范围内的元素】</b>
                    </p>
                    <p>
                        这个方法类似_.difference ，除了它接受一个 iteratee （注：迭代器）， 调用array 和 values 中的每个元素以产生比较的标准。 结果值是从第一数组中选择。iteratee 会调用一个参数：(value)。（注：首先使用迭代器分别迭代array 和
                        values中的每个元素，返回的值作为比较值）。Note: 不像_.pullAllBy，这个方法会返回一个新数组。 _.differenceBy(array, [values],{" "}
                    </p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="differenceWith" className="lodashCard">
                    <p>
                        _.differenceWith(array, [values], [comparator]) <br /> <b>【删除数组给定范围内的元素】</b>
                    </p>
                    <p>这个方法类似_.difference ，除了它接受一个 comparator （注：比较器），它调用比较array，values中的元素。 结果值是从第一数组中选择。comparator 调用参数有两个：(arrVal, othVal)。</p>
                    <p>返回一个新的数组</p>
                </Card>
            </div>
        ),
    },
    {
        key: "3",
        label: "数组拼接-数组反转-数组拼接",
        children: (
            <div className="centerTextLeft lodashWidth">
                <h3>数组拼接</h3>
                <div className="lodashPanel">
                    <Card title="concat" className="lodashCard">
                        <p>_.concat(array, [values])</p>
                        <p>创建一个新数组，将array与任何数组 或 值连接在一起。</p>
                        <p>返回一个新的数组</p>
                    </Card>
                    <Card title="join" className="lodashCard">
                        <p>_.join(array, [separator=','])</p>
                        <p>将 array 中的所有元素转换为由 separator 分隔的字符串。</p>
                        <p>返回字符串</p>
                    </Card>
                </div>
                <hr />
                <h3>数组反转</h3>
                <div className="lodashPanel">
                    <Card title="reverse" className="lodashCard">
                        <p>_.reverse(array)</p>
                        <p>反转array，使得第一个元素变为最后一个元素，第二个元素变为倒数第二个元素，依次类推。Note: 这个方法会改变原数组 array，基于Array#reverse.</p>
                        <p>返回处理后的数组</p>
                    </Card>
                </div>
                <hr />
                <h3>数组填充</h3>
                <div className="lodashPanel">
                    <Card title="fill" className="lodashCard">
                        <p>_.fill(array, value, [start=0], [end=array.length])</p>
                        <p>使用 value 值来填充（替换） array，从start位置开始, 到end位置结束（但不包含end位置）。Note: 这个方法会改变 array（注：不是创建新数组）。</p>
                        <p>返回数组</p>
                    </Card>
                </div>
                <hr />
            </div>
        ),
    },
    {
        key: "6",
        label: "数组元素搜索",
        children: (
            <div className="centerTextLeft lodashPanel lodashWidth">
                <Card title="findIndex" className="lodashCard">
                    <p>_.findIndex(array, [predicate=_.identity], [fromIndex=0])</p>
                    <p>该方法类似_.find，区别是该方法返回第一个通过 predicate 判断为真值的元素的索引值（index），而不是元素本身。</p>
                    <p>返回索引</p>
                </Card>
                <Card title="findLastIndex" className="lodashCard">
                    <p>_.findLastIndex(array, [predicate=_.identity], [fromIndex=array.length-1])</p>
                    <p>这个方式类似_.findIndex， 区别是它是从右到左的迭代集合array中的元素。</p>
                    <p>返回索引</p>
                </Card>
                <Card title="indexOf" className="lodashCard">
                    <p>_.indexOf(array, value, [fromIndex=0])</p>
                    <p>使用SameValueZero 等值比较，返回首次 value 在数组array中被找到的 索引值， 如果 fromIndex 为负值，将从数组array尾端索引进行匹配。</p>
                    <p>返回索引</p>
                </Card>
                <Card title="lastIndexOf" className="lodashCard">
                    <p>_.lastIndexOf(array, value, [fromIndex=array.length-1])</p>
                    <p>这个方法类似_.indexOf ，区别是它是从右到左遍历array的元素。</p>
                    <p>返回索引</p>
                </Card>
                <Card title="sortedIndexOf" className="lodashCard">
                    <p>
                        _.sortedIndexOf(array, value) <br />
                        <b>【找到搜索到元素的索引】</b>
                    </p>
                    <p>这个方法类似_.indexOf，除了它是在已经排序的数组array上执行二进制检索。</p>
                    <p>返回索引</p>
                </Card>
                <Card title="sortedLastIndex" className="lodashCard">
                    <p>
                        _.sortedLastIndex(array, value) <br />
                        <b>【找到搜索到元素索引的最大值】</b>
                    </p>
                    <p>此方法类似于_.sortedIndex，除了 它返回 value值 在 array 中尽可能大的索引位置（index）。</p>
                    <p>返回索引</p>
                </Card>
                <Card title="sortedLastIndexOf" className="lodashCard">
                    <p>_.sortedLastIndexOf(array, value)</p>
                    <p>这个方法类似_.lastIndexOf，除了它是在已经排序的数组array上执行二进制检索</p>
                    <p>返回索引</p>
                </Card>
            </div>
        ),
    },
    {
        key: "7",
        label: "二维数组与对象转换",
        children: (
            <div className="centerTextLeft lodashPanel lodashWidth">
                <Card title="fromPairs" className="lodashCard">
                    <p>_.fromPairs(pairs)</p>
                    <p>与_.toPairs正好相反：这个方法返回一个由键值对pairs构成的对象。</p>
                    <p>二维数组每一项转对象的键值对属性</p>
                    <p>返回一个新的对象</p>
                </Card>
                <Card title="toPairs【entries】" className="lodashCard">
                    <p>_.toPairs(object)</p>
                    <p>创建一个object对象自身可枚举属性的键值对数组。这个数组可以通过_.fromPairs撤回。如果object 是 map 或 set，返回其条目。</p>
                    <p>属性的键值对转成数组的每一项</p>
                    <p>返回键值对数组</p>
                </Card>
                <Card title="zipObject" className="lodashCard">
                    <p>
                        _.zipObject([props=[]], [values=[]]) <br />
                        <b>【 二维数组转对象属性 】</b>
                    </p>
                    <p>这个方法类似_.fromPairs，除了它接受2个数组，第一个数组中的值作为属性标识符（属性名），第二个数组中的值作为相应的属性值。</p>
                    <p>返回一个新的对象</p>
                </Card>
                <Card title="zipObjectDeep" className="lodashCard">
                    <p>
                        _.zipObjectDeep([props=[]], [values=[]]) <br />
                        <b>【 二维数组转对象属性可以递归对象属性 】</b>
                    </p>
                    <p>这个方法类似_.zipObject，除了它支持属性路径。</p>
                    <p>返回一个新的对象</p>
                </Card>
            </div>
        ),
    },
    {
        key: "8",
        label: "数组交集",
        children: (
            <div className="centerTextLeft lodashPanel lodashWidth">
                <Card title="intersection" className="lodashCard">
                    <p>_.intersection([arrays])</p>
                    <p>创建唯一值的数组，这个数组包含所有给定数组都包含的元素，使用SameValueZero进行相等性比较。（注：可以理解为给定数组的交集）</p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="intersectionBy" className="lodashCard">
                    <p>_.intersectionBy([arrays], [iteratee=_.identity])</p>
                    <p>这个方法类似_.intersection，区别是它接受一个 iteratee 调用每一个arrays的每个值以产生一个值，通过产生的值进行了比较。结果值是从第一数组中选择。iteratee 会传入一个参数：(value)。</p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="intersectionWith" className="lodashCard">
                    <p>_.intersectionWith([arrays], [comparator])</p>
                    <p>这个方法类似_.intersection，区别是它接受一个 comparator 调用比较arrays中的元素。结果值是从第一数组中选择。comparator 会传入两个参数：(arrVal, othVal)。</p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="xor" className="lodashCard">
                    <p>
                        _.xor([arrays]) <br />
                        <b>【 数组取交集后去除其并集 】</b>
                    </p>
                    <p>创建一个给定数组唯一值的数组，使用symmetric difference做等值比较。返回值的顺序取决于他们数组的出现顺序。</p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="xorBy" className="lodashCard">
                    <p>
                        _.xorBy([arrays], [iteratee=_.identity]) <br />
                        <b>【 先处理数组，然后取交集后去除其并集 】</b>
                    </p>
                    <p>这个方法类似_.xor ，除了它接受 iteratee（迭代器），这个迭代器 调用每一个 arrays（数组）的每一个值，以生成比较的新值。iteratee 调用一个参数：(value).</p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="xorWith" className="lodashCard">
                    <p>
                        _.xorWith([arrays], [comparator]) <br />
                        <b>【 先比较数组，然后取交集后去除其并集 】</b>
                    </p>
                    <p>该方法是像_.xor，除了它接受一个 comparator ，以调用比较数组的元素。 comparator 调用2个参数：(arrVal, othVal).</p>
                    <p>返回一个新的数组</p>
                </Card>
            </div>
        ),
    },
    {
        key: "9",
        label: "获取指定元素",
        children: (
            <div className="centerTextLeft lodashPanel lodashWidth">
                <Card title="head【_.first】" className="lodashCard">
                    <p>
                        _.head(array) <br />
                        <b>【获取第一个元素】</b>
                    </p>
                    <p>获取数组 array 的第一个元素。</p>
                    <p>返回第一个元素</p>
                </Card>
                <Card title="last" className="lodashCard">
                    <p>
                        {" "}
                        _.last(array) <br />
                        <b>【获取最后一个元素】</b>
                    </p>
                    <p>获取array中的最后一个元素。</p>
                    <p>返回最后一个元素</p>
                </Card>
                <Card title="nth" className="lodashCard">
                    <p>
                        _.nth(array, [n=0]) <br />
                        <b>【获取指定元素】</b>
                    </p>
                    <p>获取array数组的第n个元素。如果n为负数，则返回从数组结尾开始的第n个元素。</p>
                    <p>获取指定元素</p>
                </Card>
            </div>
        ),
    },
    {
        key: "10",
        label: "数据插入",
        children: (
            <div className="centerTextLeft lodashPanel lodashWidth">
                <Card title="sortedIndex" className="lodashCard">
                    <p>
                        _.sortedIndex(array, value) <br />
                        <b>【找到插入索引】</b>
                    </p>
                    <p>使用二进制的方式检索来决定 value值 应该插入到数组中 尽可能小的索引位置，以保证array的排序。</p>
                    <p>返回插入后的索引</p>
                </Card>
                <Card title="sortedIndexBy" className="lodashCard">
                    <p>
                        _.sortedIndexBy(array, value, [iteratee=_.identity]) <br />
                        <b>【先处理再找到插入索引】</b>
                    </p>
                    <p>这个方法类似_.sortedIndex ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）元素，返回结果和value 值比较来计算排序。iteratee 会传入一个参数：(value)。</p>
                    <p>返回索引</p>
                </Card>
                <Card title="sortedLastIndexBy" className="lodashCard">
                    <p>
                        _.sortedLastIndexBy(array, value, [iteratee=_.identity]) <br />
                        <b>【没太看明白与sortedIndexBy的区别】</b>
                    </p>
                    <p>这个方法类似_.sortedLastIndex ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）元素，返回结果和value 值比较来计算排序。iteratee 会传入一个参数：(value)。</p>
                    <p>返回索引</p>
                </Card>
            </div>
        ),
    },
    {
        key: "11",
        label: "数组排序",
        children: (
            <div className="centerTextLeft lodashPanel lodashWidth">
                <Card title="sortedUniq" className="lodashCard">
                    <p>
                        _.sortedUniq(array) <br />
                        <b>【去重排序】</b>
                    </p>
                    <p>这个方法类似_.uniq，除了它会优化排序数组。</p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="sortedUniqBy" className="lodashCard">
                    <p>
                        _.sortedUniqBy(array, [iteratee]) <br />
                        <b>【先处理再去重排序】</b>
                    </p>
                    <p>这个方法类似_.uniqBy，除了它会优化排序数组。</p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="union" className="lodashCard">
                    <p>
                        _.union([arrays]) <br />
                        <b>【 可以对多个数组排序去重 】</b>
                    </p>
                    <p>创建一个按顺序排列的唯一值的数组。所有给定数组的元素值使用SameValueZero做等值比较。（注： arrays（数组）的并集，按顺序返回，返回数组的元素是唯一的）</p>
                    <p>返回一个新的联合数组</p>
                </Card>
                <Card title="unionBy" className="lodashCard">
                    <p>
                        _.unionBy([arrays], [iteratee=_.identity]) <br />
                        <b>【 先处理后对多个数组排序去重 】</b>
                    </p>
                    <p>这个方法类似_.union ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）的每个元素以产生唯一性计算的标准。iteratee 会传入一个参数：(value)。</p>
                    <p>返回一个新的联合数组</p>
                </Card>
            </div>
        ),
    },
    {
        key: "12",
        label: "数组去重",
        children: (
            <div className="centerTextLeft lodashPanel lodashWidth">
                <Card title="union & unionBy" className="lodashCard">
                    <p>前面排序提及过</p>
                </Card>
                <Card title="unionWith" className="lodashCard">
                    <p>
                        _.unionWith([arrays], [comparator]) <br />
                        <b>【 对象数组去重 】</b>
                    </p>
                    <p>这个方法类似_.union， 除了它接受一个 comparator 调用比较arrays数组的每一个元素。 comparator 调用时会传入2个参数： (arrVal, othVal)。</p>
                    <p>返回一个新的联合数组</p>
                </Card>
                <Card title="uniq" className="lodashCard">
                    <p>
                        _.uniq(array) <br />
                        <b>【 数组去重 】</b>
                    </p>
                    <p>创建一个去重后的array数组副本。使用了SameValueZero 做等值比较。只有第一次出现的元素才会被保留。</p>
                    <p>返回去重后的数组</p>
                </Card>
                <Card title="uniqBy" className="lodashCard">
                    <p>
                        _.uniqBy(array, [iteratee=_.identity]) <br />
                        <b>【 处理数组后去重 】</b>
                    </p>
                    <p>这个方法类似_.uniq ，除了它接受一个 iteratee （迭代函数），调用每一个数组（array）的每个元素以产生唯一性计算的标准。iteratee 调用时会传入一个参数：(value)。</p>
                    <p>返回去重后的数组</p>
                </Card>
                <Card title="uniqWith" className="lodashCard">
                    <p>
                        _.uniqWith(array, [comparator]) <br />
                        <b>【 比较后数组进行去重 】</b>
                    </p>
                    <p>这个方法类似_.uniq， 除了它接受一个 comparator 调用比较arrays数组的每一个元素。 comparator 调用时会传入2个参数： (arrVal, othVal)。</p>
                    <p>返回去重后的数组</p>
                </Card>
            </div>
        ),
    },
    {
        key: "13",
        label: "数组倒置",
        children: (
            <div className="centerTextLeft lodashPanel lodashWidth">
                <Card title="unzip" className="lodashCard">
                    <p>
                        _.unzip(array) <br />
                        <b>【 数组倒置 】</b>
                    </p>
                    <p>这个方法类似于_.zip，除了它接收分组元素的数组，并且创建一个数组，分组元素到打包前的结构。（：返回数组的第一个元素包含所有的输入数组的第一元素，第一个元素包含了所有的输入数组的第二元素，依此类推。）</p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="unzipWith" className="lodashCard">
                    <p>
                        _.unzipWith(array, [iteratee=_.identity]) <br />
                        <b>【 处理分类划分后的数组数据 】</b>
                    </p>
                    <p>此方法类似于_.unzip，除了它接受一个iteratee指定重组值应该如何被组合。iteratee 调用时会传入每个分组的值： (...group)。</p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="zip" className="lodashCard">
                    <p>
                        _.zip([arrays]) <br />
                        <b>【 对二维数组的每一项设置一个数组 】</b>
                    </p>
                    <p>创建一个分组元素的数组，数组的第一个元素包含所有给定数组的第一个元素，数组的第二个元素包含所有给定数组的第二个元素，以此类推。</p>
                    <p>返回一个新的数组</p>
                </Card>
                <Card title="zipWith" className="lodashCard">
                    <p>
                        _.zipWith([arrays], [iteratee=_.identity]) <br />
                        <b>【 先转换然后按照迭代器进行处理 】</b>
                    </p>
                    <p>这个方法类似于_.zip，不同之处在于它接受一个 iteratee（迭代函数），来 指定分组的值应该如何被组合。 该iteratee调用每个组的元素： (...group).</p>
                    <p>返回一个新的数组</p>
                </Card>
            </div>
        ),
    },
];
